﻿#include <iostream>
using namespace std;
//
//class A
//{
//
//};
//
//int main()
//{
//	int i = 1;
//	double d = i;
//
//
//	const double& ref = i;
//
//	return 0;
//}


#include<iostream> 
using namespace std;

class A
{
public:
	//构造函数explicit就不再⽀持隐式类型转换 
	// explicit A(int a1) 
	A(int a1)
		:_a1(a1)
	{
	}
	//explicit A(int a1, int a2) 
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
	int Get() const
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};


class B
{
public:
	B(const A& a)
		:_b(a.Get())
	{
	}

private:
	int _b = 0;
};


int main()
{

	//内置类型--类类型对象之间转换

	

	// 构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa1 
	// 编译器遇到连续构造+拷⻉构造->优化为直接构造
	// 
	//构造
	A _aa1(1);//对比

	//隐式类型转换
	A aa1 = 1;

	aa1.Print();

	const A& _aa2 = _aa1;//对比
	const A& aa2 = 1;


	// C++11之后才⽀持多参数转化 
	A aa3 = { 2,2 };

	//类类型对象--类类型对象之间转换
	// aa3隐式类型转换为b对象 
	// 原理跟上⾯类似，需要有相关的构造函数 


	B b = aa3;
	const B& rb = aa3;

	return 0;
}